SherbyNet - /page/wikibook/entry.mu

Micron Document

<!DOCTYPE html>

<title>Haskell features</title>

</head>

Haskell features

</h1>

</header>

/* start https://en.wikipedia.org/ */

.mw-parser-output .ambox{border:1px solid #a2a9b1;border-left:10px solid #36c;background-color:#fbfbfb;box-sizing:border-box}.mw-parser-output .ambox+link+.ambox,.mw-parser-output .ambox+link+style+.ambox,.mw-parser-output .ambox+link+link+.ambox,.mw-parser-output .ambox+.mw-empty-elt+link+.ambox,.mw-parser-output .ambox+.mw-empty-elt+link+style+.ambox,.mw-parser-output .ambox+.mw-empty-elt+link+link+.ambox{margin-top:-1px}html body.mediawiki .mw-parser-output .ambox.mbox-small-left{margin:4px 1em 4px 0;overflow:hidden;width:238px;border-collapse:collapse;font-size:88%;line-height:1.25em}.mw-parser-output .ambox-speedy{border-left:10px solid #b32424;background-color:#fee7e6}.mw-parser-output .ambox-delete{border-left:10px solid #b32424}.mw-parser-output .ambox-content{border-left:10px solid #f28500}.mw-parser-output .ambox-style{border-left:10px solid #fc3}.mw-parser-output .ambox-move{border-left:10px solid #9932cc}.mw-parser-output .ambox-protection{border-left:10px solid #a2a9b1}.mw-parser-output .ambox .mbox-text{border:none;padding:0.25em 0.5em;width:100%}.mw-parser-output .ambox .mbox-image{border:none;padding:2px 0 2px 0.5em;text-align:center}.mw-parser-output .ambox .mbox-imageright{border:none;padding:2px 0.5em 2px 0;text-align:center}.mw-parser-output .ambox .mbox-empty-cell{border:none;padding:0;width:1px}.mw-parser-output .ambox .mbox-image-div{width:52px}@media(min-width:720px){.mw-parser-output .ambox{margin:0 10%}}@media print{body.ns-0 .mw-parser-output .ambox{display:none!important}}

/* end https://en.wikipedia.org/ */

</style>

This article describes the features in the <a href="Programming_language" title="Programming language">programming language</a> <a href="Haskell" title="Haskell">Haskell</a>.

<div class="mw-heading mw-heading2"><h2 id="Examples">Examples</h2></div>

<div class="mw-heading mw-heading3"><h3 id="Factorial">Factorial</h3></div>

A simple example that is often used to demonstrate the <a href="Syntax_(programming_languages)" title="Syntax (programming languages)">syntax</a> of <a href="Functional_language" class="mw-redirect" title="Functional language">functional languages</a> is the <a href="Factorial" title="Factorial">factorial</a> function for non-negative integers, shown in Haskell:

<div class="mw-highlight mw-highlight-lang-haskell mw-content-ltr" dir="ltr"><pre>factorial :: Integer -> Integer

factorial 0 = 1

</pre></div>

Or in one line:

<div class="mw-highlight mw-highlight-lang-haskell mw-content-ltr" dir="ltr"><pre>factorial n = if n > 1 then n * factorial (n-1) else 1

</pre></div>

This describes the factorial as a recursive function, with one terminating base case. It is similar to the descriptions of factorials found in mathematics textbooks. Much of Haskell code is similar to standard <a href="Mathematical_notation" title="Mathematical notation">mathematical notation</a> in facility and syntax.

The first line of the factorial function describes the type of this function; while it is optional, it is considered to be good style<a href="#cite_note-1">[1]</a> to include it. It can be read as the function factorial (<code>factorial</code>) has type (<code>::</code>) from integer to integer (<code>Integer -> Integer</code>). That is, it takes an integer as an argument, and returns another integer. The type of a definition is <a href="Type_inference" title="Type inference">inferred</a> automatically if no type annotation is given.

The second line relies on <a href="Pattern_matching" title="Pattern matching">pattern matching</a>, an important feature of Haskell. Note that parameters of a function are not in parentheses but separated by spaces. When the function's argument is 0 (zero) it will return the integer 1 (one). For all other cases the third line is tried. This is the <a href="Recursion" title="Recursion">recursion</a>, and executes the function again until the base case is reached.

Using the <code>product</code> function from the Prelude, a number of small functions analogous to <a href="C_(programming_language)" title="C (programming language)">C</a>'s <a href="C_standard_library" title="C standard library">standard library</a>, and using the Haskell syntax for arithmetic sequences, the factorial function can be expressed in Haskell as follows:

</pre></div>

Here <code>[1..n]</code> denotes the arithmetic sequence 1, 2, …, n in list form. Using the Prelude function <code>enumFromTo</code>, the expression <code>[1..n]</code> can be written as <code>enumFromTo 1 n</code>, allowing the factorial function to be expressed as

</pre></div>

which, using the <a href="Function_composition_operator" class="mw-redirect" title="Function composition operator">function composition operator</a> (expressed as a dot in Haskell) to compose the product function with the <a href="Currying" title="Currying">curried</a> enumeration function can be rewritten in <a href="Point-free_programming" class="mw-redirect" title="Point-free programming">point-free style</a>:<a href="#cite_note-2">[2]</a>

<div class="mw-highlight mw-highlight-lang-haskell mw-content-ltr" dir="ltr"><pre>factorial = product . enumFromTo 1

</pre></div>

In the Hugs interpreter, one often needs to define the function and use it on the same line separated by a <code>where</code> or <code>let</code>..<code>in</code>. For example, to test the above examples and see the output <code>120</code>:

<div class="mw-highlight mw-highlight-lang-haskell mw-content-ltr" dir="ltr"><pre>let { factorial n | n > 0 = n * factorial (n-1); factorial _ = 1 } in factorial 5

</pre></div>

or

<div class="mw-highlight mw-highlight-lang-haskell mw-content-ltr" dir="ltr"><pre>factorial 5 where factorial = product . enumFromTo 1

</pre></div>

The <a href="GHCi" class="mw-redirect" title="GHCi">GHCi</a> interpreter doesn't have this restriction and function definitions can be entered on one line (with the <code>let</code> syntax without the <code>in</code> part), and referenced later.

<div class="mw-heading mw-heading3"><h3 id="More_complex_examples">More complex examples</h3></div>

<div class="mw-heading mw-heading4"><h4 id="Calculator">Calculator</h4></div>

In the Haskell source immediately below, <code>::</code> can be read as "has type"; <code>a -> b</code> can be read as "is a function from a to b". (Thus the Haskell <code>calc :: String -> [Float]</code> can be read as "<code>calc</code> has type of a function from Strings to lists of Floats".)

In the second line <code>calc = ...</code> the equals sign can be read as "can be"; thus multiple lines with <code>calc = ...</code> can be read as multiple possible values for <code>calc</code>, depending on the circumstance detailed in each line.

A simple <a href="Reverse_Polish_notation" title="Reverse Polish notation">Reverse Polish notation</a> calculator expressed with the <a href="Higher-order_function" title="Higher-order function">higher-order function</a> <code><a href="Foldl" class="mw-redirect" title="Foldl">foldl</a></code> whose argument f is defined in a where clause using <a href="Pattern_matching" title="Pattern matching">pattern matching</a> and the <a href="Type_class" title="Type class">type class</a> Read:

<div class="mw-highlight mw-highlight-lang-haskell mw-content-ltr" dir="ltr"><pre>calc :: String -> [Float]

calc = foldl f [] . words

where

f (x:y:zs) "+" = (y + x):zs

f (x:y:zs) "-" = (y - x):zs

f (x:y:zs) "*" = (y * x):zs

f (x:y:zs) "/" = (y / x):zs

f (x:y:zs) "FLIP" = y:x:zs

f zs w = read w : zs

</pre></div>

The empty list is the initial state, and f <a href="Interpreter_(computing)" title="Interpreter (computing)">interprets</a> one word at a time, either as a function name, taking two numbers from the head of the list and pushing the result back in, or parsing the word as a <a href="Floating-point_number" class="mw-redirect" title="Floating-point number">floating-point number</a> and prepending it to the list.

<div class="mw-heading mw-heading4"><h4 id="Fibonacci_sequence">Fibonacci sequence</h4></div>

The following definition produces the list of <a href="Fibonacci_numbers" class="mw-redirect" title="Fibonacci numbers">Fibonacci numbers</a> in linear time:

</pre></div>

The infinite list is produced by <a href="Corecursion" title="Corecursion">corecursion</a> — the latter values of the list are computed on demand starting from the initial two items 0 and 1. This kind of a definition relies on <a href="Lazy_evaluation" title="Lazy evaluation">lazy evaluation</a>, an important feature of Haskell programming. For an example of how the evaluation evolves, the following illustrates the values of fibs and tail fibs after the computation of six items and shows how zipWith (+) has produced four items and proceeds to produce the next item:

<pre>fibs = 0 : 1 : 1 : 2 : 3 : 5 : ...

  + + + + + +

tail fibs = 1 : 1 : 2 : 3 : 5 : ...

  = = = = = =

zipWith ... = 1 : 2 : 3 : 5 : 8 : ...

fibs = 0 : 1 : 1 : 2 : 3 : 5 : 8 : ...

</pre>

The same function, written using <a href="Glasgow_Haskell_Compiler" title="Glasgow Haskell Compiler">Glasgow Haskell Compiler</a>'s <a href="Parallel_list_comprehension" class="mw-redirect" title="Parallel list comprehension">parallel list comprehension</a> syntax (GHC extensions must be enabled using a special command-line flag, here -XParallelListComp, or by starting the source file with <code>{-# LANGUAGE ParallelListComp #-}</code>):

<div class="mw-highlight mw-highlight-lang-haskell mw-content-ltr" dir="ltr"><pre>fibs = 0 : 1 : [ a+b | a <- fibs | b <- tail fibs ]

</pre></div>

or with regular <a href="List_comprehension" title="List comprehension">list comprehensions</a>:

<div class="mw-highlight mw-highlight-lang-haskell mw-content-ltr" dir="ltr"><pre>fibs = 0 : 1 : [ a+b | (a,b) <- zip fibs (tail fibs) ]

</pre></div>

or directly self-referencing:

<div class="mw-highlight mw-highlight-lang-haskell mw-content-ltr" dir="ltr"><pre>fibs = 0 : 1 : next fibs where next (a : t@(b:_)) = (a+b) : next t

</pre></div>

With <a href="State_(computer_science)" title="State (computer science)">stateful</a> <a href="Generator_(computer_programming)" title="Generator (computer programming)">generating</a> function:

<div class="mw-highlight mw-highlight-lang-haskell mw-content-ltr" dir="ltr"><pre>fibs = next (0,1) where next (a,b) = a : next (b, a+b)

</pre></div>

or with <code>unfoldr</code>:

<div class="mw-highlight mw-highlight-lang-haskell mw-content-ltr" dir="ltr"><pre>fibs = unfoldr (\(a,b) -> Just (a, (b, a+b))) (0, 1)

</pre></div>

or <code>scanl</code>:

</pre></div>

Using data recursion with Haskell's predefined <a href="Fixpoint_combinator" class="mw-redirect" title="Fixpoint combinator">fixpoint combinator</a>:

<div class="mw-highlight mw-highlight-lang-haskell mw-content-ltr" dir="ltr"><pre>fibs = fix (\xs -> 0 : 1 : zipWith (+) xs (tail xs)) -- zipWith version

= fix ((0:) . (1:) . (zipWith (+) <*> tail)) -- same as above, pointfree

</pre></div>

<div class="mw-heading mw-heading4"><h4 id="Factorial_2">Factorial</h4></div>

The factorial we saw previously can be written as a sequence of functions:

<div class="mw-highlight mw-highlight-lang-haskell mw-content-ltr" dir="ltr"><pre>factorial n = foldr ((.) . (*)) id [1..n] $ 1

-- factorial 5 == ((1*) .) ( ((2*) .) ( ((3*) .) ( ((4*) .) ( ((5*) .) id )))) 1

-- == (1*) . (2*) . (3*) . (4*) . (5*) . id $ 1

-- == 1* ( 2* ( 3* ( 4* ( 5* ( id 1 )))))

-- factorial 5 == ((1*) .) ( ((2*) .) ( ((3*) .) ( ((4*) .) ( ((5*) .) (const 1) )))) ()

-- == (1*) . (2*) . (3*) . (4*) . (5*) . const 1 $ ()

-- == 1* ( 2* ( 3* ( 4* ( 5* ( const 1 () )))))

factorial n = foldr (($) . (*)) 1 [1..n] = foldr ($) 1 $ map (*) [1..n]

-- factorial 5 == ((1*) $) ( ((2*) $) ( ((3*) $) ( ((4*) $) ( ((5*) $) 1 ))))

-- == (1*) $ (2*) $ (3*) $ (4*) $ (5*) $ 1

-- == 1* ( 2* ( 3* ( 4* ( 5* 1 ))))

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="More_examples">More examples</h3></div>

<div class="mw-heading mw-heading4"><h4 id="Hamming_numbers">Hamming numbers</h4></div>

A remarkably concise function that returns the list of <a href="Hamming_numbers" class="mw-redirect" title="Hamming numbers">Hamming numbers</a> in order:

<div class="mw-highlight mw-highlight-lang-haskell mw-content-ltr" dir="ltr"><pre>hamming = 1 : map (2*) hamming `union` map (3*) hamming

`union` map (5*) hamming

</pre></div>

Like the various <code>fibs</code> solutions displayed above, this uses corecursion to produce a list of numbers on demand, starting from the base case of 1 and building new items based on the preceding part of the list.

Here the function <code>union</code> is used as an operator by enclosing it in back-quotes. Its <code>case</code> clauses define how it <a href="Union_(set_theory)" title="Union (set theory)">merges</a> two ascending lists into one ascending list without duplicate items, representing <a href="Set_(mathematics)" title="Set (mathematics)">sets</a> as ordered lists. Its companion function <code>minus</code> implements <a href="Complement_(set_theory)#Relative_complement" title="Complement (set theory)">set difference</a>:

<table>

<td>

<div class="mw-highlight mw-highlight-lang-haskell mw-content-ltr" dir="ltr"><pre>union (x:xs) (y:ys) = case compare x y of

LT -> x : union xs (y:ys)

EQ -> x : union xs ys

GT -> y : union (x:xs) ys

union xs [] = xs

union [] ys = ys

</pre></div>

</td>

<td>

<div class="mw-highlight mw-highlight-lang-haskell mw-content-ltr" dir="ltr"><pre>minus (x:xs) (y:ys) = case compare x y of

LT -> x : minus xs (y:ys)

EQ -> minus xs ys

GT -> minus (x:xs) ys

minus xs _ = xs

--

</pre></div>

</td></tr></tbody></table>

It is possible to generate only the unique multiples, for more efficient operation. Since there are no duplicates, there's no need to remove them:

<div class="mw-highlight mw-highlight-lang-haskell mw-content-ltr" dir="ltr"><pre>smooth235 = 1 : foldr (\p s -> fix $ mergeBy (<) s . map (p*) . (1:)) [] [2,3,5]

where

fix f = x where x = f x -- fixpoint combinator, with sharing

</pre></div>

This uses the more efficient function <code>merge</code> which doesn't concern itself with the duplicates (also used in the following next function, <code>mergesort</code> ):

<div class="mw-highlight mw-highlight-lang-haskell mw-content-ltr" dir="ltr"><pre>mergeBy less xs ys = merge xs ys where

merge xs [] = xs

merge [] ys = ys

merge (x:xs) (y:ys) | less y x = y : merge (x:xs) ys

| otherwise = x : merge xs (y:ys)

</pre></div>

Each vertical bar ( <code>|</code> ) starts a <a href="Guard_(computer_science)" title="Guard (computer science)">guard</a> clause with a guard expression before the <code>=</code> sign and the corresponding definition after it, that is evaluated if the guard is true.

<div class="mw-heading mw-heading4"><h4 id="Mergesort">Mergesort</h4></div>

Here is a bottom-up <a href="Merge_sort" title="Merge sort">merge sort</a>, defined using the <a href="Higher-order_function" title="Higher-order function">higher-order function</a> <code>until</code>:

<div class="mw-highlight mw-highlight-lang-haskell mw-content-ltr" dir="ltr"><pre>mergesortBy less [] = []

mergesortBy less xs = head $

until (null . tail) (pairwise $ mergeBy less) [[x] | x <- xs]

pairwise f (a:b:t) = f a b : pairwise f t

pairwise f t = t

</pre></div>

<div class="mw-heading mw-heading4"><h4 id="Prime_numbers">Prime numbers</h4></div>

The mathematical definition of <a href="Prime_numbers" class="mw-redirect" title="Prime numbers">primes</a> can be translated pretty much word for word into Haskell:

<div class="mw-highlight mw-highlight-lang-haskell mw-content-ltr" dir="ltr"><pre>-- "Integers above 1 that cannot be divided by a smaller integer above 1"

-- primes = { n ∈ [2..] | ~ ∃ d ∈ [2..n-1] ⇒ rem n d = 0 }

-- = { n ∈ [2..] | ∀ d ∈ [2..n-1] ⇒ rem n d ≠ 0 }

primes = [ n | n <- [2..], all (\d -> rem n d /= 0) [2..(n-1)] ]

</pre></div>

This finds primes by <a href="Trial_division" title="Trial division">trial division</a>. Note that it is not optimized for efficiency and has very poor performance. Slightly faster (but still very slow)<a href="#cite_note-hawiki-3">[3]</a> is this code by <a href="David_Turner_(computer_scientist)" title="David Turner (computer scientist)">David Turner</a>:

sieve (p:xs) = p : sieve [x | x <- xs, rem x p /= 0]

</pre></div>

Much faster is the optimal trial division algorithm

<div class="mw-highlight mw-highlight-lang-haskell mw-content-ltr" dir="ltr"><pre>primes = 2 : [ n | n <- [3..], all ((> 0) . rem n) $

takeWhile ((<= n) . (^2)) primes]

</pre></div>

or an unbounded <a href="Sieve_of_Eratosthenes" title="Sieve of Eratosthenes">sieve of Eratosthenes</a> with postponed sieving in stages,<a href="#cite_note-4">[4]</a>

sieve (p:ps) (span (< p*p) -> (h, t)) =

h ++ sieve ps (minus t [p*p, p*p+p..])

</pre></div>

or the combined sieve implementation by <a href="Richard_Bird_(computer_scientist)" title="Richard Bird (computer scientist)">Richard Bird</a>,<a href="#cite_note-ONeill-5">[5]</a>

<div class="mw-highlight mw-highlight-lang-haskell mw-content-ltr" dir="ltr"><pre>-- "Integers above 1 without any composite numbers which

-- are found by enumeration of each prime's multiples"

primes = 2 : minus [3..]

(foldr (\(m:ms) r -> m : union ms r) []

[[p*p, p*p+p ..] | p <- primes])

</pre></div>

or an even faster <a href="Fold_(higher-order_function)#Tree-like_folds" title="Fold (higher-order function)">tree-like folding</a> variant<a href="#cite_note-6">[6]</a> with nearly optimal (for a list-based code) time complexity and very low space complexity achieved through telescoping multistage recursive production of primes:

<div class="mw-highlight mw-highlight-lang-haskell mw-content-ltr" dir="ltr"><pre>primes = 2 : _Y ((3 :) . minus [5,7..] . _U

. map (\p -> [p*p, p*p+2*p..]))

where

-- non-sharing Y combinator:

_Y g = g (_Y g) -- (g (g (g (g (...)))))

-- big union ~= nub.sort.concat

_U ((x:xs):t) = x : (union xs . _U . pairwise union) t

</pre></div>

Working on arrays by segments between consecutive squares of primes, it's

<div class="mw-highlight mw-highlight-lang-haskell mw-content-ltr" dir="ltr"><pre>import Data.Array

import Data.List (tails, inits)

primes = 2 : [ n |

(r:q:_, px) <- zip (tails (2 : [p*p | p <- primes]))

(inits primes),

(n, True) <- assocs ( accumArray (\_ _ -> False) True

(r+1,q-1)

[ (m,()) | p <- px

, s <- [ div (r+p) p * p]

, m <- [s,s+p..q-1] ] ) ]

</pre></div>

The shortest possible code is probably  <code>nubBy (((>1) .) . gcd) [2..]</code>.  It is quite slow.

<div class="mw-heading mw-heading2"><h2 id="Syntax">Syntax</h2></div>

<div class="mw-heading mw-heading3"><h3 id="Layout">Layout</h3></div>

Haskell allows <a href="Indentation_style" title="Indentation style">indentation</a> to be used to indicate the beginning of a new declaration. For example, in a where clause:

<div class="mw-highlight mw-highlight-lang-haskell mw-content-ltr" dir="ltr"><pre>product xs = prod xs 1

where

prod [] a = a

prod (x:xs) a = prod xs (a*x)

</pre></div>

The two equations for the <a href="Nested_function" title="Nested function">nested function</a> <code>prod</code> are aligned vertically, which allows the semi-colon separator to be omitted. In Haskell, indentation can be used in several syntactic constructs, including <code>do</code>, <code>let</code>, <code>case</code>, <code>class</code>, and <code>instance</code>.

The use of indentation to indicate program structure originates in <a href="Peter_J._Landin" class="mw-redirect" title="Peter J. Landin">Peter J. Landin</a>'s <a href="ISWIM" title="ISWIM">ISWIM</a> language, where it was called the <a href="Off-side_rule" title="Off-side rule">off-side rule</a>. This was later adopted by <a href="Miranda_(programming_language)" title="Miranda (programming language)">Miranda</a>, and Haskell adopted a similar (but rather more complex) version of Miranda's off-side rule, which is called "layout". Other languages to adopt <a href="Whitespace_character" title="Whitespace character">whitespace character</a>-sensitive syntax include <a href="Python_(programming_language)" title="Python (programming language)">Python</a> and <a href="F_Sharp_(programming_language)" title="F Sharp (programming language)">F#</a>.

The use of layout in Haskell is optional. For example, the function <code>product</code> above can also be written:

where { prod [] a = a; prod (x:xs) a = prod xs (a*x) }

</pre></div>

The explicit open brace after the <code>where</code> keyword indicates that separate declarations will use explicit semi-colons, and the declaration-list will be terminated by an explicit closing brace. One reason for wanting support for explicit delimiters is that it makes automatic generation of Haskell <a href="Source_code" title="Source code">source code</a> easier.

Haskell's layout rule has been criticised for its complexity. In particular, the definition states that if the parser encounters a parse error during processing of a layout section, then it should try inserting a close brace (the "parse error" rule). Implementing this rule in a traditional <a href="Parsing" title="Parsing">parsing</a> and <a href="Lexical_analysis" title="Lexical analysis">lexical analysis</a> combination requires two-way cooperation between the parser and lexical analyser, whereas in most languages, these two phases can be considered independently.

<div class="mw-heading mw-heading3"><h3 id="Function_calls">Function calls</h3></div>

Applying a function <code>f</code> to a value <code>x</code> is expressed as simply <code>f x</code>.

Haskell distinguishes function calls from infix operators syntactically, but not semantically. Function names which are composed of punctuation characters can be used as operators, as can other function names if surrounded with backticks; and operators can be used in prefix notation if surrounded with parentheses.

This example shows the ways that functions can be called:

<div class="mw-highlight mw-highlight-lang-haskell mw-content-ltr" dir="ltr"><pre>add a b = a + b

ten1 = 5 + 5

ten2 = (+) 5 5

ten3 = add 5 5

ten4 = 5 `add` 5

</pre></div>

Functions which are defined as taking several parameters can always be partially applied. Binary operators can be partially applied using section notation:

<div class="mw-highlight mw-highlight-lang-haskell mw-content-ltr" dir="ltr"><pre>ten5 = (+ 5) 5

ten6 = (5 +) 5

addfive = (5 +)

ten7 = addfive 5

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="List_comprehensions">List comprehensions</h3></div>

See <a href="List_comprehension#Overview" title="List comprehension">List comprehension#Overview</a> for the Haskell example.

<div class="mw-heading mw-heading3"><h3 id="Pattern_matching">Pattern matching</h3></div>

<a href="Pattern_matching" title="Pattern matching">Pattern matching</a> is used to match on the different constructors of algebraic data types. Here are some functions, each using pattern matching on each of the types below:

<div class="mw-highlight mw-highlight-lang-haskell mw-content-ltr" dir="ltr"><pre>-- This type signature says that empty takes a list containing any type, and returns a Bool

empty :: [a] -> Bool

empty (x:xs) = False

empty [] = True

-- Will return a value from a Maybe a, given a default value in case a Nothing is encountered

fromMaybe :: a -> Maybe a -> a

fromMaybe x (Just y) = y

fromMaybe x Nothing = x

isRight :: Either a b -> Bool

isRight (Right _) = True

isRight (Left _) = False

getName :: Person -> String

getName (Person name _ _) = name

getSex :: Person -> Sex

getSex (Person _ sex _) = sex

getAge :: Person -> Int

getAge (Person _ _ age) = age

</pre></div>

Using the above functions, along with the <a href="Map_(higher-order_function)" title="Map (higher-order function)"><code>map</code></a> function, we can apply them to each element of a list, to see their results:

<div class="mw-highlight mw-highlight-lang-haskell mw-content-ltr" dir="ltr"><pre>map empty [[1,2,3],[],[2],[1..]]

-- returns [False,True,False,False]

map (fromMaybe 0) [Just 2,Nothing,Just 109238, Nothing]

-- returns [2,0,109238,0]

map isRight [Left "hello", Right 6, Right 23, Left "world"]

-- returns [False, True, True, False]

map getName [Person "Sarah" Female 20, Person "Alex" Male 20, tom]

-- returns ["Sarah", "Alex", "Tom"], using the definition for tom above

</pre></div>

<ul><li>Abstract Types</li>

<li>Lists</li></ul>

<div class="mw-heading mw-heading3"><h3 id="Tuples">Tuples</h3></div>

<a href="Tuple_(computer_science)" class="mw-redirect" title="Tuple (computer science)">Tuples</a> in haskell can be used to hold a fixed number of elements. They are used to group pieces of data of differing types:

<div class="mw-highlight mw-highlight-lang-haskell mw-content-ltr" dir="ltr"><pre>account :: (String, Integer, Double) -- The type of a three-tuple, representing

-- a name, balance, and interest rate

account = ("John Smith",102894,5.25)

</pre></div>

Tuples are commonly used in the zip* functions to place adjacent elements in separate lists together in tuples (zip4 to zip7 are provided in the Data.List module):

<div class="mw-highlight mw-highlight-lang-haskell mw-content-ltr" dir="ltr"><pre>-- The definition of the zip function. Other zip* functions are defined similarly

zip :: [x] -> [y] -> [(x,y)]

zip (x:xs) (y:ys) = (x,y) : zip xs ys

zip _ _ = []

zip [1..5] "hello"

-- returns [(1,'h'),(2,'e'),(3,'l'),(4,'l'),(5,'o')]

-- and has type [(Integer, Char)]

zip3 [1..5] "hello" [False, True, False, False, True]

-- returns [(1,'h',False),(2,'e',True),(3,'l',False),(4,'l',False),(5,'o',True)]

-- and has type [(Integer,Char,Bool)]

</pre></div>

In the GHC compiler, tuples are defined with sizes from 2 elements up to 62 elements.

<ul><li><a href="Record_(computer_science)" title="Record (computer science)">Records</a></li></ul>

<div class="mw-heading mw-heading2"><h2 id="Namespaces">Namespaces</h2></div>

In the <a href="#More_complex_examples">§ More complex examples</a> section above, <code>calc</code> is used in two senses, showing that there is a Haskell type class namespace and also a namespace for values:

<ol><li>a Haskell <a href="Type_class" title="Type class">type class</a> for <code>calc</code>. The <a href="Domain_of_a_function" title="Domain of a function">domain</a> and <a href="Range_of_a_function" title="Range of a function">range</a> can be explicitly denoted in a Haskell type class.</li>

<li>a Haskell value, formula, or expression for <code>calc</code>.</li></ol>

<div class="mw-heading mw-heading2"><h2 id="Typeclasses_and_polymorphism">Typeclasses and polymorphism</h2></div>

<div class="mw-heading mw-heading3"><h3 id="Algebraic_data_types">Algebraic data types</h3></div>

<a href="Algebraic_data_types" class="mw-redirect" title="Algebraic data types">Algebraic data types</a> are used extensively in Haskell. Some examples of these are the built in list, <code>Maybe</code> and <code>Either</code> types:

<div class="mw-highlight mw-highlight-lang-haskell mw-content-ltr" dir="ltr"><pre>-- A list of a's ([a]) is either an a consed (:) onto another list of a's, or an empty list ([])

data [a] = a : [a] | []

-- Something of type Maybe a is either Just something, or Nothing

data Maybe a = Just a | Nothing

-- Something of type Either atype btype is either a Left atype, or a Right btype

data Either a b = Left a | Right b

</pre></div>

Users of the language can also define their own <a href="Abstract_data_type" title="Abstract data type">abstract data types</a>. An example of an ADT used to represent a person's name, sex and age might look like:

<div class="mw-highlight mw-highlight-lang-haskell mw-content-ltr" dir="ltr"><pre>data Sex = Male | Female

data Person = Person String Sex Int -- Notice that Person is both a constructor and a type

-- An example of creating something of type Person

tom :: Person

tom = Person "Tom" Male 27

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Type_system">Type system</h3></div>

<ul><li><a href="Type_class" title="Type class">Type classes</a></li>

<li>Type defaulting</li>

<li>Overloaded literals</li>

<li>Higher kinded polymorphism</li>

<li>Multi-parameter type classes</li>

<li>Functional dependencies</li></ul>

<div class="mw-heading mw-heading2"><h2 id="Monads_and_input/output">Monads and input/output</h2></div>

<ul><li>Overview of the <a href="Monad_(functional_programming)" title="Monad (functional programming)">monad</a> framework:</li>

<li>Applications

<ul><li>Monadic IO</li>

<li>Do-notation</li>

<li>References</li>

<li>Exceptions</li></ul></li></ul>

<div class="mw-heading mw-heading3"><h3 id="ST_monad">ST monad</h3></div>

The ST monad allows writing <a href="Imperative_programming" title="Imperative programming">imperative programming</a> algorithms in Haskell, using mutable variables (STRefs) and mutable arrays (STArrays and STUArrays). The advantage of the ST monad is that it allows writing code that has internal side effects, such as destructively updating mutable variables and arrays, while containing these effects inside the monad. The result of this is that functions written using the ST monad appear pure to the rest of the program. This allows using imperative code where it may be impractical to write functional code, while still keeping all the safety that pure code provides.

Here is an example program (taken from the Haskell wiki page on the <a rel="nofollow" class="external text" href="http://haskell.org/haskellwiki/Monad/ST">ST monad</a>) that takes a list of numbers, and sums them, using a mutable variable:

<div class="mw-highlight mw-highlight-lang-haskell mw-content-ltr" dir="ltr"><pre>import Control.Monad.ST

import Data.STRef

import Control.Monad

sumST :: Num a => [a] -> a

sumST xs = runST $ do -- runST takes stateful ST code and makes it pure.

summed <- newSTRef 0 -- Create an STRef (a mutable variable)

forM_ xs $ \x -> do -- For each element of the argument list xs ..

modifySTRef summed (+x) -- add it to what we have in n.

readSTRef summed -- read the value of n, which will be returned by the runST above.

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="STM_monad">STM monad</h3></div>

/* start https://en.wikipedia.org/ */

.mw-parser-output .hatnote{font-style:italic}.mw-parser-output div.hatnote{padding-left:1.6em;margin-bottom:0.5em}.mw-parser-output .hatnote i{font-style:normal}.mw-parser-output .hatnote+link+.hatnote{margin-top:-0.5em}@media print{body.ns-0 .mw-parser-output .hatnote{display:none!important}}

/* end https://en.wikipedia.org/ */

</style><div role="note" class="hatnote navigation-not-searchable">Main article: <a href="Concurrent_Haskell" title="Concurrent Haskell">Concurrent Haskell</a></div>

The STM monad is an implementation of <a href="Software_Transactional_Memory" class="mw-redirect" title="Software Transactional Memory">Software Transactional Memory</a> in Haskell. It is implemented in the GHC compiler, and allows for mutable variables to be modified in <a href="Database_transaction" title="Database transaction">transactions</a>.

<div class="mw-heading mw-heading3"><h3 id="Arrows">Arrows</h3></div>

<ul><li>Applicative Functors</li>

<li>Arrows</li></ul>

As Haskell is a pure functional language, functions cannot have side effects. Being non-strict, it also does not have a well-defined evaluation order. This is a challenge for real programs, which among other things need to interact with an environment. Haskell solves this with <a href="Monad_(functional_programming)" title="Monad (functional programming)">monadic types</a> that leverage the type system to ensure the proper sequencing of imperative constructs. The typical example is <a href="Input/output" title="Input/output">input/output</a> (I/O), but monads are useful for many other purposes, including mutable state, concurrency and transactional memory, exception handling, and error propagation.

Haskell provides a special syntax for monadic expressions, so that side-effecting programs can be written in a style similar to current imperative programming languages; no knowledge of the <a href="Monad_(category_theory)" title="Monad (category theory)">mathematics behind monadic I/O</a> is required for this. The following program reads a name from the command line and outputs a greeting message:

name <- getLine

putStr ("Hello, " ++ name ++ "!\n")

</pre></div>

The do-notation eases working with monads. This do-expression is equivalent to, but (arguably) easier to write and understand than, the <a href="Desugared" class="mw-redirect" title="Desugared">de-sugared</a> version employing the monadic operators directly:

<div class="mw-highlight mw-highlight-lang-haskell mw-content-ltr" dir="ltr"><pre>main = putStrLn "What's your name?" >> getLine >>= \ name -> putStr ("Hello, " ++ name ++ "!\n")

</pre></div>

<dl><dd>See also <a href="https://en.wikibooks.org/wiki/Transwiki:List_of_hello_world_programs#Haskell" class="extiw external" title="wikibooks:Transwiki:List of hello world programs">wikibooks:Transwiki:List of hello world programs#Haskell</a> for another example that prints text.</dd></dl>

<div class="mw-heading mw-heading2"><h2 id="Concurrency">Concurrency</h2></div>

The Haskell language definition includes neither <a href="Concurrency_(computer_science)" title="Concurrency (computer science)">concurrency</a> nor <a href="Parallel_computing" title="Parallel computing">parallelism</a>, although GHC supports both.

<div role="note" class="hatnote navigation-not-searchable">Main article: <a href="Concurrent_Haskell" title="Concurrent Haskell">Concurrent Haskell</a></div>

<a href="Concurrent_Haskell" title="Concurrent Haskell">Concurrent Haskell</a> is an extension to Haskell that supports <a href="Thread_(computing)" title="Thread (computing)">threads</a> and <a href="Synchronization_(computer_science)" title="Synchronization (computer science)">synchronization</a>.<a href="#cite_note-7">[7]</a> GHC's implementation of Concurrent Haskell is based on multiplexing lightweight Haskell threads onto a few heavyweight <a href="Operating_system" title="Operating system">operating system</a> (OS) threads,<a href="#cite_note-marlow2009-8">[8]</a> so that Concurrent Haskell programs run in parallel via <a href="Symmetric_multiprocessing" title="Symmetric multiprocessing">symmetric multiprocessing</a>. The runtime can support millions of simultaneous threads.<a href="#cite_note-dons-multicore-9">[9]</a>

The GHC implementation employs a dynamic pool of OS threads, allowing a Haskell thread to make a blocking system call without blocking other running Haskell threads.<a href="#cite_note-marlow2004-10">[10]</a> Hence the lightweight Haskell threads have the characteristics of heavyweight OS threads, and a programmer can be unaware of the implementation details.

Recently, Concurrent Haskell has been extended with support for <a href="Software_transactional_memory" title="Software transactional memory">software transactional memory</a> (STM), which is a concurrency abstraction in which compound operations on shared data are performed atomically, as transactions.<a href="#cite_note-stm-11">[11]</a> GHC's STM implementation is the only STM implementation to date to provide a static compile-time guarantee preventing non-transactional operations from being performed within a transaction. The Haskell STM library also provides two operations not found in other STMs: <code>retry</code> and <code>orElse</code>, which together allow blocking operations to be defined in a <a href="Software_transactional_memory#Composable_operations" title="Software transactional memory">modular and composable fashion</a>.

<div class="mw-heading mw-heading2"><h2 id="References">References</h2></div>

/* start https://en.wikipedia.org/ */

.mw-parser-output .reflist{margin-bottom:0.5em;list-style-type:decimal}@media screen{.mw-parser-output .reflist{font-size:90%}}.mw-parser-output .reflist .references{font-size:100%;margin-bottom:0;list-style-type:inherit}.mw-parser-output .reflist-columns-2{column-width:30em}.mw-parser-output .reflist-columns-3{column-width:25em}.mw-parser-output .reflist-columns{margin-top:0.3em}.mw-parser-output .reflist-columns ol{margin-top:0}.mw-parser-output .reflist-columns li{page-break-inside:avoid;break-inside:avoid-column}.mw-parser-output .reflist-upper-alpha{list-style-type:upper-alpha}.mw-parser-output .reflist-upper-roman{list-style-type:upper-roman}.mw-parser-output .reflist-lower-alpha{list-style-type:lower-alpha}.mw-parser-output .reflist-lower-greek{list-style-type:lower-greek}.mw-parser-output .reflist-lower-roman{list-style-type:lower-roman}

/* end https://en.wikipedia.org/ */

</style><div class="reflist">

<li id="cite_note-1"><a href="#cite_ref-1">^</a> HaskellWiki: <a rel="nofollow" class="external text" href="http://www.haskell.org/haskellwiki/Type_signatures_as_good_style">Type signatures as good style</a>

</li>

<li id="cite_note-2"><a href="#cite_ref-2">^</a> HaskellWiki: <a rel="nofollow" class="external text" href="http://haskell.org/haskellwiki/Pointfree">Pointfree</a>

</li>

/* start https://en.wikipedia.org/ */

.mw-parser-output cite.citation{font-style:inherit;word-wrap:break-word}.mw-parser-output .citation q{quotes:"\"""\"""'""'"}.mw-parser-output .citation:target{background-color:rgba(0,127,255,0.133)}.mw-parser-output .id-lock-free.id-lock-free a{background:url("./mw/Lock-green.svg")right 0.1em center/9px no-repeat}.mw-parser-output .id-lock-limited.id-lock-limited a,.mw-parser-output .id-lock-registration.id-lock-registration a{background:url("./mw/Lock-gray-alt-2.svg")right 0.1em center/9px no-repeat}.mw-parser-output .id-lock-subscription.id-lock-subscription a{background:url("./mw/Lock-red-alt-2.svg")right 0.1em center/9px no-repeat}.mw-parser-output .cs1-ws-icon a{background:url("./mw/Wikisource-logo.svg")right 0.1em center/12px no-repeat}body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-free a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-limited a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-registration a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-subscription a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .cs1-ws-icon a{background-size:contain;padding:0 1em 0 0}.mw-parser-output .cs1-code{color:inherit;background:inherit;border:none;padding:inherit}.mw-parser-output .cs1-hidden-error{display:none;color:var(--color-error,#d33)}.mw-parser-output .cs1-visible-error{color:var(--color-error,#d33)}.mw-parser-output .cs1-maint{display:none;color:#085;margin-left:0.3em}.mw-parser-output .cs1-kern-left{padding-left:0.2em}.mw-parser-output .cs1-kern-right{padding-right:0.2em}.mw-parser-output .citation .mw-selflink{font-weight:inherit}@media screen{.mw-parser-output .cs1-format{font-size:95%}html.skin-theme-clientpref-night .mw-parser-output .cs1-maint{color:#18911f}}@media screen and (prefers-color-scheme:dark){html.skin-theme-clientpref-os .mw-parser-output .cs1-maint{color:#18911f}}

/* end https://en.wikipedia.org/ */

</style><cite class="citation web cs1"><a rel="nofollow" class="external text" href="http://www.haskell.org/haskellwiki/Prime_numbers#Turner.27s_sieve_-_Trial_division">"Prime numbers - HaskellWiki"</a>. www.haskell.org.</cite>

</li>

<li id="cite_note-4"><a href="#cite_ref-4">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="http://www.haskell.org/haskellwiki/Prime_numbers#Postponed">"Prime numbers - HaskellWiki"</a>. www.haskell.org.</cite>

</li>

<li id="cite_note-ONeill-5"><a href="#cite_ref-ONeill_5-0">^</a> O'Neill, Melissa E., <a rel="nofollow" class="external text" href="http://www.cs.hmc.edu/~oneill/papers/Sieve-JFP.pdf">"The Genuine Sieve of Eratosthenes"</a>, <a href="Journal_of_Functional_Programming" title="Journal of Functional Programming">Journal of Functional Programming</a>, Published online by Cambridge University Press 9 October 2008 <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.1017%2FS0956796808007004">10.1017/S0956796808007004</a>, pp. 10, 11.

</li>

<li id="cite_note-6"><a href="#cite_ref-6">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="http://www.haskell.org/haskellwiki/Prime_numbers#Tree_merging">"Prime numbers - HaskellWiki"</a>. www.haskell.org.</cite>

</li>

<li id="cite_note-7"><a href="#cite_ref-7">^</a> Simon Peyton Jones, Andrew Gordon, and Sigbjorn Finne. <a rel="nofollow" class="external text" href="http://www.haskell.org/ghc/docs/papers/concurrent-haskell.ps.gz">Concurrent Haskell</a>. ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (PoPL). 1996. (Some sections are out of date with respect to the current implementation.)

</li>

<li id="cite_note-marlow2009-8"><a href="#cite_ref-marlow2009_8-0">^</a> <a rel="nofollow" class="external text" href="http://www.haskell.org/~simonmar/papers/multicore-ghc.pdf">Runtime Support for Multicore Haskell</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20100705223412/http://www.haskell.org/~simonmar/papers/multicore-ghc.pdf">Archived</a> 2010-07-05 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a> (Simon Marlow, Simon Peyton Jones, Satnam Singh) ICFP '09: Proceedings of the 14th ACM SIGPLAN international conference on Functional programming, Edinburgh, Scotland, August 2009

</li>

<li id="cite_note-dons-multicore-9"><a href="#cite_ref-dons-multicore_9-0">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="http://donsbot.wordpress.com/2009/09/05/defun-2009-multicore-programming-in-haskell-now/">"DEFUN 2009: Multicore Programming in Haskell Now!"</a>. 5 September 2009.</cite>

</li>

<li id="cite_note-marlow2004-10"><a href="#cite_ref-marlow2004_10-0">^</a> <a rel="nofollow" class="external text" href="http://www.haskell.org/~simonmar/papers/conc-ffi.pdf">Extending the Haskell Foreign Function Interface with Concurrency</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20100703070838/http://www.haskell.org/~simonmar/papers/conc-ffi.pdf">Archived</a> 2010-07-03 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a> (Simon Marlow, Simon Peyton Jones, Wolfgang Thaller) Proceedings of the ACM SIGPLAN workshop on Haskell, pages 57--68, Snowbird, Utah, USA, September 2004

</li>

<li id="cite_note-stm-11"><a href="#cite_ref-stm_11-0">^</a> <cite id="CITEREFHarrisMarlowPeyton_JonesHerlihy2005" class="citation conference cs1">Harris, Tim; <a href="Simon_Marlow" title="Simon Marlow">Marlow, Simon</a>; <a href="Simon_Peyton_Jones" title="Simon Peyton Jones">Peyton Jones, Simon</a>; Herlihy, Maurice (2005). "Composable memory transactions". Proceedings of the tenth ACM SIGPLAN symposium on Principles and practice of parallel programming. <a href="CiteSeerX_(identifier)" class="mw-redirect" title="CiteSeerX (identifier)">CiteSeerX</a> <a rel="nofollow" class="external text" href="https://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.67.3686">10.1.1.67.3686</a>.</cite>

</li>

</ol></div></div>

/* start https://en.wikipedia.org/ */

.mw-parser-output .hlist dl,.mw-parser-output .hlist ol,.mw-parser-output .hlist ul{margin:0;padding:0}.mw-parser-output .hlist dd,.mw-parser-output .hlist dt,.mw-parser-output .hlist li{margin:0;display:inline}.mw-parser-output .hlist.inline,.mw-parser-output .hlist.inline dl,.mw-parser-output .hlist.inline ol,.mw-parser-output .hlist.inline ul,.mw-parser-output .hlist dl dl,.mw-parser-output .hlist dl ol,.mw-parser-output .hlist dl ul,.mw-parser-output .hlist ol dl,.mw-parser-output .hlist ol ol,.mw-parser-output .hlist ol ul,.mw-parser-output .hlist ul dl,.mw-parser-output .hlist ul ol,.mw-parser-output .hlist ul ul{display:inline}.mw-parser-output .hlist .mw-empty-li{display:none}.mw-parser-output .hlist dt::after{content:": "}.mw-parser-output .hlist dd::after,.mw-parser-output .hlist li::after{content:" · ";font-weight:bold}.mw-parser-output .hlist dd:last-child::after,.mw-parser-output .hlist dt:last-child::after,.mw-parser-output .hlist li:last-child::after{content:none}.mw-parser-output .hlist dd dd:first-child::before,.mw-parser-output .hlist dd dt:first-child::before,.mw-parser-output .hlist dd li:first-child::before,.mw-parser-output .hlist dt dd:first-child::before,.mw-parser-output .hlist dt dt:first-child::before,.mw-parser-output .hlist dt li:first-child::before,.mw-parser-output .hlist li dd:first-child::before,.mw-parser-output .hlist li dt:first-child::before,.mw-parser-output .hlist li li:first-child::before{content:" (";font-weight:normal}.mw-parser-output .hlist dd dd:last-child::after,.mw-parser-output .hlist dd dt:last-child::after,.mw-parser-output .hlist dd li:last-child::after,.mw-parser-output .hlist dt dd:last-child::after,.mw-parser-output .hlist dt dt:last-child::after,.mw-parser-output .hlist dt li:last-child::after,.mw-parser-output .hlist li dd:last-child::after,.mw-parser-output .hlist li dt:last-child::after,.mw-parser-output .hlist li li:last-child::after{content:")";font-weight:normal}.mw-parser-output .hlist ol{counter-reset:listitem}.mw-parser-output .hlist ol>li{counter-increment:listitem}.mw-parser-output .hlist ol>li::before{content:" "counter(listitem)"\a0 "}.mw-parser-output .hlist dd ol>li:first-child::before,.mw-parser-output .hlist dt ol>li:first-child::before,.mw-parser-output .hlist li ol>li:first-child::before{content:" ("counter(listitem)"\a0 "}

/* end https://en.wikipedia.org/ */

</style><style data-mw-deduplicate="TemplateStyles:r1236075235">

/* start https://en.wikipedia.org/ */

.mw-parser-output .navbox{box-sizing:border-box;border:1px solid #a2a9b1;width:100%;clear:both;font-size:88%;text-align:center;padding:1px;margin:1em auto 0}.mw-parser-output .navbox .navbox{margin-top:0}.mw-parser-output .navbox+.navbox,.mw-parser-output .navbox+.navbox-styles+.navbox{margin-top:-1px}.mw-parser-output .navbox-inner,.mw-parser-output .navbox-subgroup{width:100%}.mw-parser-output .navbox-group,.mw-parser-output .navbox-title,.mw-parser-output .navbox-abovebelow{padding:0.25em 1em;line-height:1.5em;text-align:center}.mw-parser-output .navbox-group{white-space:nowrap;text-align:right}.mw-parser-output .navbox,.mw-parser-output .navbox-subgroup{background-color:#fdfdfd}.mw-parser-output .navbox-list{line-height:1.5em;border-color:#fdfdfd}.mw-parser-output .navbox-list-with-group{text-align:left;border-left-width:2px;border-left-style:solid}.mw-parser-output tr+tr>.navbox-abovebelow,.mw-parser-output tr+tr>.navbox-group,.mw-parser-output tr+tr>.navbox-image,.mw-parser-output tr+tr>.navbox-list{border-top:2px solid #fdfdfd}.mw-parser-output .navbox-title{background-color:#ccf}.mw-parser-output .navbox-abovebelow,.mw-parser-output .navbox-group,.mw-parser-output .navbox-subgroup .navbox-title{background-color:#ddf}.mw-parser-output .navbox-subgroup .navbox-group,.mw-parser-output .navbox-subgroup .navbox-abovebelow{background-color:#e6e6ff}.mw-parser-output .navbox-even{background-color:#f7f7f7}.mw-parser-output .navbox-odd{background-color:transparent}.mw-parser-output .navbox .hlist td dl,.mw-parser-output .navbox .hlist td ol,.mw-parser-output .navbox .hlist td ul,.mw-parser-output .navbox td.hlist dl,.mw-parser-output .navbox td.hlist ol,.mw-parser-output .navbox td.hlist ul{padding:0.125em 0}.mw-parser-output .navbox .navbar{display:block;font-size:100%}.mw-parser-output .navbox-title .navbar{float:left;text-align:left;margin-right:0.5em}body.skin--responsive .mw-parser-output .navbox-image img{max-width:none!important}@media print{body.ns-0 .mw-parser-output .navbox{display:none!important}}

/* end https://en.wikipedia.org/ */

</style></div><div role="navigation" class="navbox" aria-labelledby="Haskell_programming542" style="padding:3px"><table class="nowraplinks hlist mw-collapsible autocollapse navbox-inner" style="border-spacing:0;background:transparent;color:inherit"><tbody><tr><th scope="col" class="navbox-title" colspan="3"><style data-mw-deduplicate="TemplateStyles:r1239400231">

/* start https://en.wikipedia.org/ */

.mw-parser-output .navbar{display:inline;font-size:88%;font-weight:normal}.mw-parser-output .navbar-collapse{float:left;text-align:left}.mw-parser-output .navbar-boxtext{word-spacing:0}.mw-parser-output .navbar ul{display:inline-block;white-space:nowrap;line-height:inherit}.mw-parser-output .navbar-brackets::before{margin-right:-0.125em;content:"[ "}.mw-parser-output .navbar-brackets::after{margin-left:-0.125em;content:" ]"}.mw-parser-output .navbar li{word-spacing:-0.125em}.mw-parser-output .navbar a>span,.mw-parser-output .navbar a>abbr{text-decoration:inherit}.mw-parser-output .navbar-mini abbr{font-variant:small-caps;border-bottom:none;text-decoration:none;cursor:inherit}.mw-parser-output .navbar-ct-full{font-size:114%;margin:0 7em}.mw-parser-output .navbar-ct-mini{font-size:114%;margin:0 4em}html.skin-theme-clientpref-night .mw-parser-output .navbar li a abbr{color:var(--color-base)!important}@media(prefers-color-scheme:dark){html.skin-theme-clientpref-os .mw-parser-output .navbar li a abbr{color:var(--color-base)!important}}@media print{.mw-parser-output .navbar{display:none!important}}

/* end https://en.wikipedia.org/ */

</style><div id="Haskell_programming542" style="font-size:114%;margin:0 4em"><a href="Haskell" title="Haskell">Haskell</a> programming</div></th></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Software" title="Software">Software</a></th><td class="navbox-list-with-group navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em"></div><table class="nowraplinks navbox-subgroup" style="border-spacing:0"><tbody><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Programming_language_implementation" title="Programming language implementation">Implementations</a> ()</th><td class="navbox-list-with-group navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em"></div><table class="nowraplinks navbox-subgroup" style="border-spacing:0"><tbody><tr><td colspan="2" class="navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Generic_programming#Generic_Haskell" title="Generic programming">Generic Haskell</a>°</li>

<li><a href="Glasgow_Haskell_Compiler" title="Glasgow Haskell Compiler">Glasgow Haskell Compiler</a>°

<ul><li><a href="Template_Haskell" title="Template Haskell">Template Haskell</a>°</li></ul></li>

<li><a href="Gofer_(programming_language)" title="Gofer (programming language)">Gofer</a>° → <a href="Hugs_(interpreter)" title="Hugs (interpreter)">Hugs</a>°</li>

<li>York Haskell Compiler° (<a href="Yhc" title="Yhc">Yhc</a>)</li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Dialect_(computing)" class="mw-redirect" title="Dialect (computing)">Dialects</a></th><td class="navbox-list-with-group navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em"></div><table class="nowraplinks navbox-subgroup" style="border-spacing:0"><tbody><tr><td colspan="2" class="navbox-list navbox-even" style="width:100%;padding:0"><div style="padding:0 0.25em">

<li><a href="Cryptol" title="Cryptol">Cryptol</a>°</li>

<li><a href="Curry_(programming_language)" title="Curry (programming language)">Curry</a>°</li>

<li><a href="Idris_(programming_language)" title="Idris (programming language)">Idris</a>°</li>

<li><a href="%CE%A9mega" title="Ωmega">Ωmega</a>°</li>

<li><a href="Orwell_(programming_language)" title="Orwell (programming language)">Orwell</a>°</li>

<li><a href="PureScript" title="PureScript">PureScript</a>°</li>

<li><a href="TidalCycles" title="TidalCycles">TidalCycles</a>°</li>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Electronic_design_automation" title="Electronic design automation">Electronic design</a></th><td class="navbox-list-with-group navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em">

<li><a href="Bluespec" title="Bluespec">Bluespec</a> <a href="SystemVerilog" title="SystemVerilog">SystemVerilog</a> (BSV)</li></ul>

</div></td></tr></tbody></table><div></div></td></tr></tbody></table><div></div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Library_(computing)" title="Library (computing)">Libraries</a></th><td class="navbox-list-with-group navbox-list navbox-even" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Concurrent_Haskell" title="Concurrent Haskell">Concurrent Haskell</a>°</li>

<li><a href="Haskell_Platform" title="Haskell Platform">Haskell Platform</a>°</li>

<li><a href="Parsec_(parser)" title="Parsec (parser)">Parsec</a>°</li>

<li><a href="QuickCheck" title="QuickCheck">QuickCheck</a>°</li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Package_manager" title="Package manager">Package managers</a></th><td class="navbox-list-with-group navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Cabal_(software)" title="Cabal (software)">Cabal</a>°</li>

<li><a href="Stack_(Haskell)" title="Stack (Haskell)">Stack</a>°</li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Windowing_system" title="Windowing system">Windowing systems</a></th><td class="navbox-list-with-group navbox-list navbox-even" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Fudgets" title="Fudgets">Fudgets</a></li>

<li><a href="WxHaskell" title="WxHaskell">wxHaskell</a>°</li>

<li><a href="Xmonad" title="Xmonad">xmonad</a>°</li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Web_framework" title="Web framework">Web frameworks</a></th><td class="navbox-list-with-group navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Servant_(web_framework)" title="Servant (web framework)">Servant</a>°</li>

<li><a href="Yesod_(web_framework)" title="Yesod (web framework)">Yesod</a>°</li></ul>

</div></td></tr><tr><td colspan="2" class="navbox-list navbox-even" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Cardano_(blockchain_platform)" title="Cardano (blockchain platform)">Cardano</a>°</li>

<li><a href="Darcs" title="Darcs">Darcs</a>°</li>

<li><a href="Ganeti" title="Ganeti">Ganeti</a>°</li>

<li><a href="Git-annex" title="Git-annex">git-annex</a>°</li>

<li><a href="Haddock_(software)" title="Haddock (software)">Haddock</a>°</li>

<li><a href="HaXml" title="HaXml">HaXml</a>°</li>

<li><a href="Liquid_Haskell" title="Liquid Haskell">Liquid Haskell</a>°</li>

<li><a href="LOLITA" title="LOLITA">LOLITA</a></li>

<li><a href="Pandoc" title="Pandoc">Pandoc</a>°</li>

<li><a href="Paradox_(theorem_prover)" title="Paradox (theorem prover)">Paradox</a>°</li>

<li><a href="SQream_DB" title="SQream DB">SQream DB</a></li></ul>

</div></td></tr></tbody></table><div></div></td><td class="noviewer navbox-image" rowspan="3" style="width:1px;padding:0 0 0 2px"><div></div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%">Book</th><td class="navbox-list-with-group navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Real_World_Haskell" title="Real World Haskell">Real World Haskell</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Community_of_practice" title="Community of practice">Community</a></th><td class="navbox-list-with-group navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em"></div><table class="nowraplinks navbox-subgroup" style="border-spacing:0"><tbody><tr><th id="Eponym10" scope="row" class="navbox-group" style="width:1%"><a href="Eponym" title="Eponym">Eponym</a></th><td class="navbox-list-with-group navbox-list navbox-even" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Haskell_Curry" title="Haskell Curry">Haskell Curry</a></li></ul>

</div></td></tr><tr><td colspan="2" class="navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Arvind_(computer_scientist)" title="Arvind (computer scientist)">Arvind</a></li>

<li><a href="Lennart_Augustsson" title="Lennart Augustsson">Lennart Augustsson</a></li>

<li><a href="Richard_Bird_(computer_scientist)" title="Richard Bird (computer scientist)">Richard Bird</a></li>

<li><a href="Jeremy_Gibbons" title="Jeremy Gibbons">Jeremy Gibbons</a></li>

<li><a href="Andrew_D._Gordon" title="Andrew D. Gordon">Andrew D. Gordon</a></li>

<li><a href="Paul_Hudak" title="Paul Hudak">Paul Hudak</a></li>

<li><a href="John_Hughes_(computer_scientist)" title="John Hughes (computer scientist)">John Hughes</a></li>

<li><a href="John_Launchbury" title="John Launchbury">John Launchbury</a></li>

<li><a href="John_MacFarlane_(philosopher)" title="John MacFarlane (philosopher)">John MacFarlane</a></li>

<li><a href="Simon_Marlow" title="Simon Marlow">Simon Marlow</a></li>

<li><a href="Conor_McBride" title="Conor McBride">Conor McBride</a></li>

<li><a href="Erik_Meijer_(computer_scientist)" title="Erik Meijer (computer scientist)">Erik Meijer</a></li>

<li><a href="Simon_Peyton_Jones" title="Simon Peyton Jones">Simon Peyton Jones</a></li>

<li><a href="David_Roundy" title="David Roundy">David Roundy</a></li>

<li><a href="Audrey_Tang" title="Audrey Tang">Audrey Tang</a></li>

<li><a href="Simon_Thompson_(professor)" title="Simon Thompson (professor)">Simon Thompson</a></li>

<li><a href="Philip_Wadler" title="Philip Wadler">Philip Wadler</a></li></ul>

</div></td></tr></tbody></table><div></div></td></tr><tr><td class="navbox-abovebelow" colspan="3"><div>Italics = discontinued • ° = <a href="Open-source_software" title="Open-source software">Open-source software</a> <a href="https://en.wikibooks.org/wiki/Haskell" class="extiw external" title="wikibooks:Haskell">Book</a> Category:Family Category:Software</div></td></tr></tbody></table></div></div><div><div class="zim-footer">

This article is issued from <a class="external text" title="Last edited on 2024-02-27" href="https://en.wikipedia.org/wiki/?title=Haskell_features&oldid=1210545958">Wikipedia</a>. The text is available under <a class="external text" href="https://creativecommons.org/licenses/by-sa/4.0/deed.en">Creative Commons Attribution-Share Alike 4.0</a> unless otherwise noted. Additional terms may apply for the media files.

</div>

</div></div>

</div>

</main>

</div>

</body></html>